home *** CD-ROM | disk | FTP | other *** search
/ Freelog Special Edition 10 / FreelogHS10.iso / Buzz / Buzz_Advanced_Pack.exe / {app} / Dev / Delay / Delay.cpp next >
C/C++ Source or Header  |  2001-08-27  |  10KB  |  558 lines
  1.  
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include <assert.h>
  6. #include <math.h>
  7. #include "../../MachineInterface.h"
  8.  
  9. double const SilentEnough = log(1.0 / 32768);
  10.  
  11. #define MAX_TAPS        8
  12.  
  13. CMachineParameter const paraLength = 
  14. { 
  15.     pt_word,                                        // type
  16.     "Length",
  17.     "Length in length units",                        // description
  18.     1,                                                // MinValue    
  19.     32768,                                            // MaxValue
  20.     65535,                                            // NoValue
  21.     MPF_STATE,                                        // Flags
  22.     3
  23. };
  24.  
  25. #define UNIT_TICK        0
  26. #define UNIT_MS            1
  27. #define UNIT_SAMPLE        2
  28. #define UNIT_256        3
  29.  
  30. CMachineParameter const paraDryThru = 
  31. { 
  32.     pt_switch,                                        // type
  33.     "Dry thru",
  34.     "Dry thru (1 = yes, 0 = no)",                    // description
  35.     -1,                                                // MinValue    
  36.     -1,                                                // MaxValue
  37.     SWITCH_NO,                                        // NoValue
  38.     MPF_STATE,                                        // Flags
  39.     SWITCH_ON
  40. };
  41.  
  42. CMachineParameter const paraUnit =
  43. { 
  44.     pt_byte,                                         // type
  45.     "Length unit",
  46.     "Length unit (0 = tick (default), 1 = ms, 2 = sample, 3 = 256th of tick)",        
  47.     0,                                                // MinValue    
  48.     3,                                                // MaxValue
  49.     0xff,                                            // NoValue
  50.     MPF_STATE,                                        // Flags
  51.     0
  52. };
  53.  
  54.  
  55. CMachineParameter const paraFeedback = 
  56. { 
  57.     pt_byte,                                        // type
  58.     "Feedback",
  59.     "Feedback (00 = -100%, 40=0%, 80 = 100%)",        // description
  60.     0,                                                // MinValue    
  61.     128,                                            // MaxValue
  62.     255,                                            // NoValue
  63.     MPF_STATE,                                        // Flags
  64.     0x60
  65. };
  66.  
  67. CMachineParameter const paraWetOut = 
  68. { 
  69.     pt_byte,                                        // type
  70.     "Wet out",
  71.     "Wet out (00 = 0%, 80 = 100%)",                    // description
  72.     0,                                                // MinValue    
  73.     128,                                            // MaxValue
  74.     255,                                            // NoValue
  75.     MPF_STATE,                                        // Flags
  76.     0x30
  77. };
  78.  
  79.  
  80. CMachineParameter const *pParameters[] = 
  81. { 
  82.     ¶DryThru,
  83.     ¶Length,
  84.     ¶Unit,
  85.     ¶Feedback,
  86.     ¶WetOut,
  87. };
  88.  
  89. CMachineAttribute const attrMaxDelay = 
  90. {
  91.     "Max Delay (ms)",
  92.     1,
  93.     100000,
  94.     1000    
  95. };
  96.  
  97. CMachineAttribute const *pAttributes[] = 
  98. {
  99.     &attrMaxDelay
  100. };
  101.  
  102. #pragma pack(1)
  103.  
  104. class gvals
  105. {
  106. public:
  107.     byte drythru;
  108. };
  109.  
  110. class tvals
  111. {
  112. public:
  113.     word length;
  114.     byte unit;
  115.     byte feedback;
  116.     byte wetout;
  117. };
  118.  
  119. class avals
  120. {
  121. public:
  122.     int maxdelay;
  123. };
  124.  
  125. #pragma pack()
  126.  
  127. CMachineInfo const MacInfo = 
  128. {
  129.     MT_EFFECT,                                // type
  130.     MI_VERSION,
  131.     0,                                        // flags
  132.     1,                                        // min tracks
  133.     MAX_TAPS,                                // max tracks
  134.     1,                                        // numGlobalParameters
  135.     4,                                        // numTrackParameters
  136.     pParameters,
  137.     1,
  138.     pAttributes,
  139. #ifdef _DEBUG
  140.     "Jeskola Delay (Debug build)",            // name
  141. #else
  142.     "Jeskola Delay",
  143. #endif
  144.     "Delay",                                // short name
  145.     "Oskari Tammelin",                        // author
  146.     NULL
  147. };
  148.  
  149. class CTrack
  150. {
  151. public:
  152.     float *Buffer;
  153.     int Length;
  154.     int Pos;
  155.     float Feedback;
  156.     float WetOut;
  157.     int Unit;
  158. };
  159.  
  160.  
  161. class mi : public CMachineInterface
  162. {
  163. public:
  164.     mi();
  165.     virtual ~mi();
  166.  
  167.     virtual void Init(CMachineDataInput * const pi);
  168.     virtual void Tick();
  169.     virtual bool Work(float *psamples, int numsamples, int const mode);
  170.  
  171.     virtual void SetNumTracks(int const n);
  172.  
  173.     virtual void AttributesChanged();
  174.  
  175.     virtual char const *DescribeValue(int const param, int const value);
  176.  
  177. private:
  178.     void InitTrack(int const i);
  179.     void ResetTrack(int const i);
  180.  
  181.     void TickTrack(CTrack *pt, tvals *ptval);
  182.     void WorkTrack(CTrack *pt, float *pin, float *pout, int numsamples, int const mode);
  183.  
  184. private:
  185.     int MaxDelay;    // in samples
  186.     int IdleCount;    // in samples
  187.     int DelayTime;
  188.     bool IdleMode;
  189.     bool DryThru;
  190.  
  191. private:
  192.     int numTracks;
  193.     CTrack Tracks[MAX_TAPS];
  194.  
  195.     avals aval;
  196.     gvals gval;
  197.     tvals tval[MAX_TAPS];
  198.  
  199.  
  200. };
  201.  
  202. DLL_EXPORTS
  203.  
  204. mi::mi()
  205. {
  206.     GlobalVals = &gval;
  207.     TrackVals = tval;
  208.     AttrVals = (int *)&aval;
  209. }
  210.  
  211. mi::~mi()
  212. {
  213.     for (int c = 0; c < MAX_TAPS; c++)
  214.     {
  215.         delete[] Tracks[c].Buffer;
  216.     }
  217. }
  218.  
  219. char const *mi::DescribeValue(int const param, int const value)
  220. {
  221.     static char txt[16];
  222.  
  223.     switch(param)
  224.     {
  225.     case 1:        // length
  226.         return NULL;
  227.         break;
  228.     case 2:        // unit
  229.         switch(value)
  230.         {
  231.         case 0: return "tick";
  232.         case 1: return "ms";
  233.         case 2: return "sample";
  234.         case 3: return "tick/256";
  235.         }
  236.         break;
  237.     case 3:        // feedback
  238.         sprintf(txt, "%.1f%%", (double)(value-64) * (100.0 / 64.0));
  239.         break;
  240.     case 4:        // wetout
  241.         sprintf(txt, "%.1f%%", (double)value * (100.0 / 128.0));
  242.         break;
  243.     default:
  244.         return NULL;
  245.     }
  246.  
  247.     return txt;
  248. }
  249.  
  250.  
  251.  
  252. void mi::Init(CMachineDataInput * const pi)
  253. {
  254.     numTracks = 1;
  255.     DryThru = true;
  256.  
  257.     for (int c = 0; c < MAX_TAPS; c++)
  258.     {
  259.         Tracks[c].Buffer = NULL;
  260.         Tracks[c].Unit = UNIT_TICK;
  261.         Tracks[c].Length = pMasterInfo->SamplesPerTick * 3;
  262.         Tracks[c].Pos = 0;
  263.         Tracks[c].Feedback = 0.3f;
  264.         Tracks[c].WetOut = 0;
  265.     }
  266.  
  267.     Tracks[0].WetOut = 0.3f;    // enable first track
  268.  
  269.     IdleMode = true;
  270.     IdleCount = 0;
  271.  
  272. }
  273.  
  274. void mi::AttributesChanged()
  275. {
  276.     MaxDelay = (int)(pMasterInfo->SamplesPerSec * (aval.maxdelay / 1000.0));
  277.     for (int c = 0; c < numTracks; c++)
  278.         InitTrack(c);
  279. }
  280.  
  281.  
  282. void mi::SetNumTracks(int const n)
  283. {
  284.     if (numTracks < n)
  285.     {
  286.         for (int c = numTracks; c < n; c++)
  287.             InitTrack(c);
  288.     }
  289.     else if (n < numTracks)
  290.     {
  291.         for (int c = n; c < numTracks; c++)
  292.             ResetTrack(c);
  293.     
  294.     }
  295.     numTracks = n;
  296.  
  297. }
  298.  
  299.  
  300. void mi::InitTrack(int const i)
  301. {
  302.     delete[] Tracks[i].Buffer;
  303.     Tracks[i].Buffer = new float [MaxDelay];
  304.     memset(Tracks[i].Buffer, 0, MaxDelay*4);
  305.     Tracks[i].Pos = 0;
  306.     if (Tracks[i].Length > MaxDelay)
  307.         Tracks[i].Length = MaxDelay;
  308. }
  309.  
  310. void mi::ResetTrack(int const i)
  311. {
  312.     delete[] Tracks[i].Buffer;
  313.     Tracks[i].Buffer = NULL;
  314. }
  315.  
  316.  
  317. void mi::TickTrack(CTrack *pt, tvals *ptval)
  318. {
  319.     if (ptval->unit != paraUnit.NoValue)
  320.         pt->Unit = ptval->unit;
  321.  
  322.     if (ptval->length != paraLength.NoValue)
  323.     {
  324.         switch(pt->Unit)
  325.         {
  326.         case UNIT_MS:
  327.             pt->Length = (int)(pMasterInfo->SamplesPerSec * (ptval->length / 1000.0));
  328.             if (pt->Length < 1)
  329.                 pt->Length = 1;
  330.             break;
  331.         case UNIT_SAMPLE:
  332.             pt->Length = ptval->length;
  333.             break;
  334.         case UNIT_TICK:
  335.             pt->Length = pMasterInfo->SamplesPerTick * ptval->length;
  336.             break;
  337.         case UNIT_256:
  338.             pt->Length = (pMasterInfo->SamplesPerTick * ptval->length) >> 8;
  339.             if (pt->Length < 1)
  340.                 pt->Length = 1;
  341.             break;
  342.         }
  343.  
  344.     }
  345.  
  346.     if (pt->Length > MaxDelay)
  347.     {
  348.         pt->Length = MaxDelay;
  349.     }
  350.     
  351.  
  352.     if (pt->Pos >= pt->Length)
  353.         pt->Pos = 0;
  354.  
  355.     if (ptval->feedback != paraFeedback.NoValue)
  356.     {
  357.         pt->Feedback = (float)((ptval->feedback - 64) * (1.0 / 64.0)); 
  358.     }
  359.  
  360.     if (ptval->wetout != paraWetOut.NoValue)
  361.         pt->WetOut = (float)(ptval->wetout * (1.0 / 128.0));
  362.     
  363. }
  364.  
  365. void mi::Tick()
  366. {
  367.     for (int c = 0; c < numTracks; c++)
  368.         TickTrack(Tracks + c, tval+c);
  369.  
  370.  
  371.     // find max delay time slow we know when to stop wasting CPU time
  372.     int maxdt = 0;
  373.     for (c = 0; c < numTracks; c++)
  374.     {
  375.         int dt = Tracks[c].Length + (int)(SilentEnough / log(fabs(Tracks[c].Feedback)) * Tracks[c].Length); 
  376.         if (dt > maxdt)
  377.             maxdt = dt;
  378.     }
  379.     
  380.     DelayTime = maxdt;
  381.  
  382.  
  383.     
  384.     if (gval.drythru != SWITCH_NO)
  385.         DryThru = gval.drythru != 0;
  386. }
  387.  
  388. #pragma optimize ("a", on) 
  389.  
  390. static void DoWork(float *pin, float *pout, float *pbuf, int c, double const wetout, double const feedback)
  391. {
  392.     do
  393.     {
  394.  
  395.         double delay = *pbuf;
  396.         *pbuf++ = (float)(feedback * delay + *pin++);
  397.         *pout++ += (float)(delay * wetout);
  398.  
  399.     } while(--c);
  400. }
  401.  
  402. static void DoWorkNoFB(float *pin, float *pout, float *pbuf, int c, double const wetout)
  403. {
  404.     do
  405.     {
  406.  
  407.         double delay = *pbuf;
  408.         *pbuf++ = (float)(*pin++);
  409.         *pout++ += (float)(delay * wetout);
  410.  
  411.     } while(--c);
  412. }
  413.  
  414. static void DoWorkNoInput(float *pout, float *pbuf, int c, double const wetout, double const feedback)
  415. {
  416.     do
  417.     {
  418.         double delay = *pbuf;
  419.         *pbuf++ = (float)(feedback * delay);
  420.         *pout++ += (float)(delay * wetout);
  421.  
  422.     } while(--c);
  423. }
  424.  
  425.  
  426.  
  427. static void DoWorkNoInputNoFB(float *pout, float *pbuf, int c, double const wetout)
  428. {
  429.  
  430.     do
  431.     {
  432.         double delay = *pbuf;
  433.         *pbuf++ = 0;
  434.         *pout++ += (float)(delay * wetout);
  435.     } while(--c);
  436. }
  437.  
  438. static void DoWorkNoInputNoOutput(float *pbuf, int c, double const feedback)
  439. {
  440.     do
  441.     {
  442.         *pbuf = (float)(*pbuf * feedback);
  443.         pbuf++;
  444.     } while(--c);
  445. }
  446.  
  447. static void DoWorkNoOutput(float *pin, float *pbuf, int c, double const feedback)
  448. {
  449.     do
  450.     {
  451.  
  452.         double delay = *pbuf;
  453.         double dry = *pin++;
  454.         *pbuf++ = (float)(feedback * delay + dry);
  455.  
  456.     } while(--c);
  457. }
  458.  
  459. static void DoWorkNoOutputNoFB(float *psamples, float *pbuf, int c)
  460. {
  461.     memcpy(pbuf, psamples, c*4);
  462. }
  463.  
  464.  
  465. #pragma optimize ("", on)
  466.  
  467.  
  468. void mi::WorkTrack(CTrack *pt, float *pin, float *pout, int numsamples, int const mode)
  469. {
  470.     do
  471.     {
  472.         int count = __min(numsamples, pt->Length - pt->Pos);
  473.  
  474.         if (count > 0)
  475.         {
  476.             if (mode == WM_NOIO)
  477.             {
  478.                 if (pt->Feedback != 0)
  479.                     DoWorkNoInputNoOutput(pt->Buffer + pt->Pos, count, pt->Feedback);
  480.             }
  481.             else if (mode == WM_WRITE)
  482.             {
  483.                 if (pt->Feedback != 0)
  484.                     DoWorkNoInput(pout, pt->Buffer + pt->Pos, count, pt->WetOut, pt->Feedback);
  485.                 else
  486.                     DoWorkNoInputNoFB(pout, pt->Buffer + pt->Pos, count, pt->WetOut);
  487.             }
  488.             else if (mode == WM_READ)
  489.             {
  490.                 if (pt->Feedback != 0)
  491.                     DoWorkNoOutput(pin, pt->Buffer + pt->Pos, count, pt->Feedback);
  492.                 else
  493.                     DoWorkNoOutputNoFB(pin, pt->Buffer + pt->Pos, count);
  494.  
  495.             }
  496.             else
  497.             {
  498.                 if (pt->Feedback != 0)
  499.                     DoWork(pin, pout, pt->Buffer + pt->Pos, count, pt->WetOut, pt->Feedback);
  500.                 else
  501.                     DoWorkNoFB(pin, pout, pt->Buffer + pt->Pos, count, pt->WetOut);
  502.             }
  503.             
  504.             pin += count;
  505.             pout += count;
  506.             numsamples -= count;
  507.             pt->Pos += count;
  508.         } 
  509.  
  510.         if (pt->Pos == pt->Length)
  511.             pt->Pos = 0;
  512.  
  513.     } while(numsamples > 0);
  514.  
  515. }
  516.  
  517. bool mi::Work(float *psamples, int numsamples, int const mode)
  518. {
  519.     if (mode & WM_READ)
  520.     {
  521.         IdleMode = false;
  522.         IdleCount = 0;
  523.     }
  524.     else
  525.     {
  526.         if (IdleMode)
  527.         {
  528.             return false;
  529.         }
  530.         else
  531.         {
  532.             IdleCount += numsamples;
  533.             if (IdleCount >= DelayTime + MAX_BUFFER_LENGTH)
  534.             {
  535.                 // clear all buffers
  536.                 for (int c = 0; c < numTracks; c++)
  537.                     memset(Tracks[c].Buffer, 0, Tracks[c].Length*4);
  538.                 IdleMode = true;
  539.             }
  540.         }
  541.     }
  542.  
  543.     float *paux = pCB->GetAuxBuffer();
  544.  
  545.     if (mode & WM_READ)
  546.         memcpy(paux, psamples, numsamples*4);
  547.  
  548.     if (!DryThru || !(mode & WM_READ))
  549.         memset(psamples, 0, numsamples*4);
  550.  
  551.     for (int c = 0; c < numTracks; c++)
  552.         WorkTrack(Tracks + c, paux, psamples, numsamples, mode);
  553.  
  554.     return true;
  555. }
  556.  
  557.  
  558.